package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;
import javax.script.*;

/**
 * API de persistência de dados da entidade TIPOS_IMPLEMENTACOES
 * @author Gerado pelo Telescope
 */
public class EntTiposImplementacoes extends Entity {
    
    public final static String ENTITY_NAME = "RTSYSINF.TIPOS_IMPLEMENTACOES";
    public final static String TABLE_NAME = "TIPOS_IMPLEMENTACOES";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntTiposImplementacoes() {
        super();
        initialize();
    }
    
    public EntTiposImplementacoes(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aTipoImplementacao = new DomOpcao(this,"TIPO_IMPLEMENTACAO", "Tipo de implementacao"); 
        aTipoImplementacao.setRequired(true);
        oTipoImplementacao = new DomOpcao();
        aScript = new DomFlag(this,"SCRIPT", "Script"); 
        aScript.setRequired(true);
        aScript.setDefaultValue("S");
        oScript = new DomFlag();
        aCriarOperacao = new DomFlag(this,"CRIAR_OPERACAO", "Criar operação"); 
        aCriarOperacao.setRequired(true);
        oCriarOperacao = new DomFlag();
        aMecanismoExecucao = new DomText(this,"MECANISMO_EXECUCAO", "Mecanismo de execução"); 
        aMecanismoExecucao.setRequired(true);
        oMecanismoExecucao = new DomText();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Tipo de implementacao
    private DomOpcao aTipoImplementacao;
    private DomOpcao oTipoImplementacao;
    
    // Script
    private DomFlag aScript;
    private DomFlag oScript;
    
    // Criar operação
    private DomFlag aCriarOperacao;
    private DomFlag oCriarOperacao;
    
    // Mecanismo de execução
    private DomText aMecanismoExecucao;
    private DomText oMecanismoExecucao;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntTiposImplementacoes id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo TIPO_IMPLEMENTACAO">
    
    public EntTiposImplementacoes tipoImplementacao(String value) {
        setTipoImplementacao(value);
        return this;
    }
    
    public void setTipoImplementacao(DomOpcao value) {
        if (value == null || value.isNull()) {
            nullifyTipoImplementacao();
        } else {
            aTipoImplementacao.setValue(value.getValue());
            if (aTipoImplementacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTipoImplementacao(String value) {
        if (value == null) {
            nullifyTipoImplementacao();
        } else {
            aTipoImplementacao.setValue(value);
            if (aTipoImplementacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTipoImplementacao(Object value) {
        aTipoImplementacao.setValue(value);
        if (aTipoImplementacao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyTipoImplementacao() {
        if (!aTipoImplementacao.isNull()) {
            aTipoImplementacao.setNull(true);
            setModified(true);
        }
    }
    
    public DomOpcao getTipoImplementacao() {
        return aTipoImplementacao;
    }
    
    public DomOpcao oldTipoImplementacao() {
        return oTipoImplementacao;
    }
    
    public String valueOfTipoImplementacao() {
        return aTipoImplementacao.getValue();
    }
    
    public boolean isTipoImplementacaoModified() {
        return aTipoImplementacao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SCRIPT">
    
    public EntTiposImplementacoes script(String value) {
        setScript(value);
        return this;
    }
    
    public void setScript(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyScript();
        } else {
            aScript.setValue(value.getValue());
            if (aScript.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setScript(String value) {
        if (value == null) {
            nullifyScript();
        } else {
            aScript.setValue(value);
            if (aScript.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setScript(Object value) {
        aScript.setValue(value);
        if (aScript.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyScript() {
        if (!aScript.isNull()) {
            aScript.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getScript() {
        return aScript;
    }
    
    public DomFlag oldScript() {
        return oScript;
    }
    
    public String valueOfScript() {
        return aScript.getValue();
    }
    
    public boolean isScriptModified() {
        return aScript.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CRIAR_OPERACAO">
    
    public EntTiposImplementacoes criarOperacao(String value) {
        setCriarOperacao(value);
        return this;
    }
    
    public void setCriarOperacao(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyCriarOperacao();
        } else {
            aCriarOperacao.setValue(value.getValue());
            if (aCriarOperacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCriarOperacao(String value) {
        if (value == null) {
            nullifyCriarOperacao();
        } else {
            aCriarOperacao.setValue(value);
            if (aCriarOperacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCriarOperacao(Object value) {
        aCriarOperacao.setValue(value);
        if (aCriarOperacao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyCriarOperacao() {
        if (!aCriarOperacao.isNull()) {
            aCriarOperacao.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getCriarOperacao() {
        return aCriarOperacao;
    }
    
    public DomFlag oldCriarOperacao() {
        return oCriarOperacao;
    }
    
    public String valueOfCriarOperacao() {
        return aCriarOperacao.getValue();
    }
    
    public boolean isCriarOperacaoModified() {
        return aCriarOperacao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo MECANISMO_EXECUCAO">
    
    public EntTiposImplementacoes mecanismoExecucao(String value) {
        setMecanismoExecucao(value);
        return this;
    }
    
    public void setMecanismoExecucao(DomText value) {
        if (value == null || value.isNull()) {
            nullifyMecanismoExecucao();
        } else {
            aMecanismoExecucao.setValue(value.getValue());
            if (aMecanismoExecucao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMecanismoExecucao(String value) {
        if (value == null) {
            nullifyMecanismoExecucao();
        } else {
            aMecanismoExecucao.setValue(value);
            if (aMecanismoExecucao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMecanismoExecucao(Object value) {
        aMecanismoExecucao.setValue(value);
        if (aMecanismoExecucao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyMecanismoExecucao() {
        if (!aMecanismoExecucao.isNull()) {
            aMecanismoExecucao.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getMecanismoExecucao() {
        return aMecanismoExecucao;
    }
    
    public DomText oldMecanismoExecucao() {
        return oMecanismoExecucao;
    }
    
    public String valueOfMecanismoExecucao() {
        return aMecanismoExecucao.getValue();
    }
    
    public boolean isMecanismoExecucaoModified() {
        return aMecanismoExecucao.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteRestrict() throws AdsException {
        // Nullify cascade RTSYSINF.OPERACOES_SISTEMAS.FK_OPRSIS_TIPO_IMPLEMENTACAO
        {
            EntOperacoesSistemas external = new EntOperacoesSistemas(ctx);
            external.findByTipoImplementacao(valueOfId());
            if (external.next()) {
                throw new AdsException("RTSYSINF.OPERACOES_SISTEMAS.FK_OPRSIS_TIPO_IMPLEMENTACAO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Operações dos sistemas fazendo referencia para este registro");
            }
            external.close();
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_OPRSIS_TIPO_IMPLEMENTACAO") >= 0) {
                e = new AdsException("RTSYSINF.OPERACOES_SISTEMAS.FK_OPRSIS_TIPO_IMPLEMENTACAO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Operações dos sistemas fazendo referencia para este registro! (FK_OPRSIS_TIPO_IMPLEMENTACAO)");
                return e;
            } else {
                e = new AdsException("RTSYSINF.TIPOS_IMPLEMENTACOES.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("PK_TIPMPL") >= 0) {
                e = new AdsException("RTSYSINF.TIPOS_IMPLEMENTACOES.PK_TIPMPL", 
                        Severity.ERROR,
                        "ID duplicado! (PK_TIPMPL)");
                return e;
            } else if (msg.indexOf("UK_TIIPMPL") >= 0) {
                e = new AdsException("RTSYSINF.TIPOS_IMPLEMENTACOES.UK_TIIPMPL", 
                        Severity.ERROR,
                        "Registro duplicado! Linguagem de programação é uma chave única Tipo de implementacao ${TIPO_IMPLEMENTACAO} (UK_TIIPMPL)");
                return e;
            } else {
                e = new AdsException("RTSYSINF.TIPOS_IMPLEMENTACOES.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aTipoImplementacao);
            allAttributes.add(aScript);
            allAttributes.add(aCriarOperacao);
            allAttributes.add(aMecanismoExecucao);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getTipoImplementacao().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByTipoImplementacao(String tipoImplementacao) throws AdsException {
        findBy(new String[] {"TIPO_IMPLEMENTACAO"},
                new Object[] {tipoImplementacao});
    }
    /**
     * Retorna os registros de OPERACOES_SISTEMAS que referenciam este registro através do atributo TIPO_IMPLEMENTACAO_ID
     */
    public EntOperacoesSistemas findAllOperacoesSistemasTipoImplementacao() throws AdsException {
        return findAllOperacoesSistemasTipoImplementacao("order by ID");
    }
    
    /**
     * Retorna os registros de OPERACOES_SISTEMAS que referenciam este registro através do atributo TIPO_IMPLEMENTACAO_ID
     */
    public EntOperacoesSistemas findAllOperacoesSistemasTipoImplementacao(String sqlAppend) throws AdsException {
        EntOperacoesSistemas out = new EntOperacoesSistemas(ctx);
        out.find("select ID from OPERACOES_SISTEMAS where TIPO_IMPLEMENTACAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oId.setValue(aId);
        oScript.setValue(aScript);
        oCriarOperacao.setValue(aCriarOperacao);
        oTipoImplementacao.setValue(aTipoImplementacao);
        oMecanismoExecucao.setValue(aMecanismoExecucao);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntTiposImplementacoes.class);
            rule.setName("PK_TIPMPL");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntTiposImplementacoes.class);
            rule.setName("UK_TIIPMPL");
            rule.addAttribute(new DomOpcao("TIPO_IMPLEMENTACAO",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getScript().isNull()) {
            setScript(getScript().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * Atualizar tipos de implementação.
     * <p>
     * Rotine que atualiza os tipos de implementação disponíveis no ambiente.
     */
    public void atualizarTiposImplementacoes() throws AdsException {
        // <user-code id="2505728" parentId="2505727" hashcode="50e201e8" length="588">
        // import javax.script.*;
        EntTiposImplementacoes tipo = new EntTiposImplementacoes(ctx);
        ScriptEngineManager sem = new ScriptEngineManager();
        for (ScriptEngineFactory sef : sem.getEngineFactories()) {
            String name = sef.getEngineName();
            try {
                tipo.findByTipoImplementacao(name);
            } catch (RecordNotFoundException ex) {
                tipo.nullify();
                tipo.setTipoImplementacao(name);
                tipo.setMecanismoExecucao(sef.getScriptEngine().getClass().getName());
                tipo.setCriarOperacao("S");
                tipo.setScript("S");
                tipo.ins();
            }
        }
        // </user-code>
    }
}
